#include "netcheck.h"

bool ConnectToServer(int& s, sockaddr_in& serv_addr, int portNum,
        std::string hostname)
{
    hostent* hp;

    if ((hp = gethostbyname(hostname.c_str())) == 0)
    {
        perror("Error calling gethostbyname()");
        return false;
    }

    bzero(&serv_addr, sizeof (serv_addr));
    bcopy(hp->h_addr_list[0], &serv_addr.sin_addr, hp->h_length);
    serv_addr.sin_family = hp->h_addrtype;
    serv_addr.sin_port = htons(portNum);

    if ((s = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("Error calling socket()");
        return false;
    }

    fprintf(stderr, "Server addres: %s\n", inet_ntoa(serv_addr.sin_addr));

    if (connect(s, (sockaddr*) & serv_addr, sizeof (serv_addr)) == -1)
    {
        perror("Error creating connect()");
        return false;
    }
    return true;
}

void DoNetWork(std::string hostname, int portnum,
        std::vector<char> data)
{
    int socket(0);
    sockaddr_in serv_addr;

    if (!ConnectToServer(socket, serv_addr, portnum, hostname))
    {
        std::cout << "connection error!" << std::endl;
        return;
    };
    SendData(socket, data);
    std::string temp;
    RecieveData(socket, temp);
    std::cout << "temp = " << temp << std::endl;

    close(socket);

}

bool SendData(const int s, std::vector<char> data)
{
    const int strLenBuf = 10;

    send(s, data.data(), strLenBuf, 0);


    //    std::string str (data.begin(), data.end());
    //
    //    std::stringstream ss;
    //    ss << str.length();
    //
    //    std::vector<char> sizeVal;
    //    std::string temp(ss.str());
    //    std::copy(temp.begin(), temp.end(), std::back_inserter(sizeVal));
    //    sizeVal.push_back('\0');
    //    sizeVal.resize(strLenBuf);

    //    send(s, sizeVal.data(), strLenBuf, 0);
    //    send(s, str.c_str(), str.length(), 0);
    //    cout << "sending string size = " << str.length() << endl;

    return true;
}

bool RecieveData(const int ns, std::string str)
{
    int nsize(0);
    const int strLenBuf = 10;
    const int bufsize = 65536;

    std::vector<char> buff;
    buff.resize(bufsize);
    
    int len = 10;

//    std::vector<char> sizeVal;
//    sizeVal.resize(strLenBuf);

//    if ((nsize = (recv(ns, sizeVal.data(), strLenBuf, 0) != 0)) == -1)
//    {
//        perror("Error calling recv()");
//        exit(1);
//    }
//    int len = atoi(sizeVal.data());

    std::stringstream ss;
    while ((nsize = recv(ns, buff.data(), buff.size(), 0)) != 0)
    {
        if (nsize == -1)
        {
            perror("Error calling recv()");
            exit(1);
        }

        ss.write(buff.data(), nsize);
        if (static_cast<int> (ss.str().size()) == len) break;

    }
    std::cout << "recived string size = " << ss.str().size() << std::endl;

    //    Cryptor coder;
    //    if (!ss.str().empty())
    //    {
    //        coder = recv_struct(ss.str());
    //        //        rcvvec = coder.recv_vector_int(ss.str());
    //    }
    //    rcvvec = coder.vi;

    return true;
}

